home *** CD-ROM | disk | FTP | other *** search
/ Champak 49 / Volume 49 - JOGO DISK .iso / Games / gasmania.swf / scripts / DefineSprite_943 / frame_1 / DoAction.as
Encoding:
Text File  |  2007-10-01  |  90.9 KB  |  1,865 lines

  1. var ┬º\x01┬º = 359;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 359)
  6.    {
  7.       set("\x01",eval("\x01") - 251);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 410)
  12.    {
  13.       set("\x01",eval("\x01") + 401);
  14.       continue;
  15.    }
  16.    if(eval("\x01") == 833)
  17.    {
  18.       set("\x01",eval("\x01") - 699);
  19.       continue;
  20.    }
  21.    if(eval("\x01") == 108)
  22.    {
  23.       set("\x01",eval("\x01") + 759);
  24.       if(┬º┬ºpop())
  25.       {
  26.          set("\x01",eval("\x01") - 178);
  27.       }
  28.       continue;
  29.    }
  30.    if(eval("\x01") == 378)
  31.    {
  32.       set("\x01",eval("\x01") - 319);
  33.       if(┬º┬ºpop())
  34.       {
  35.          set("\x01",eval("\x01") + 351);
  36.       }
  37.       continue;
  38.    }
  39.    if(eval("\x01") == 72)
  40.    {
  41.       set("\x01",eval("\x01") + 289);
  42.       continue;
  43.    }
  44.    if(eval("\x01") == 342)
  45.    {
  46.       set("\x01",eval("\x01") + 371);
  47.       continue;
  48.    }
  49.    if(eval("\x01") == 905)
  50.    {
  51.       set("\x01",eval("\x01") - 72);
  52.       addr3704:
  53.       set(┬º┬ºpop(),┬º┬ºpop() - 464);
  54.       addr3305:
  55.       ┬º┬ºpush(true);
  56.       if(eval("\x01") == 362)
  57.       {
  58.          set("\x01",eval("\x01") + 524);
  59.          ┬º┬ºgoto(addr3305);
  60.          ┬º┬ºpush(true);
  61.       }
  62.       if(eval("\x01") != 613)
  63.       {
  64.          if(eval("\x01") == 517)
  65.          {
  66.             set("\x01",eval("\x01") + 112);
  67.             ┬º┬ºgoto(addr3305);
  68.          }
  69.          if(eval("\x01") == 886)
  70.          {
  71.             set("\x01",eval("\x01") - 69);
  72.             if(!┬º┬ºpop())
  73.             {
  74.                addr3368:
  75.                ┬º┬ºgoto(addr3305);
  76.             }
  77.             set("\x01",eval("\x01") - 365);
  78.             ┬º┬ºgoto(addr3368);
  79.          }
  80.          if(eval("\x01") == 4)
  81.          {
  82.             set("\x01",eval("\x01") + 428);
  83.             ┬º┬ºgoto(addr3305);
  84.          }
  85.          if(eval("\x01") != 476)
  86.          {
  87.             if(eval("\x01") == 652)
  88.             {
  89.                set("\x01",eval("\x01") - 183);
  90.                ┬º┬ºgoto(addr3305);
  91.             }
  92.             if(eval("\x01") == 838)
  93.             {
  94.                set("\x01",eval("\x01") - 521);
  95.                addr2228:
  96.                set(┬º┬ºpop(),┬º┬ºpop() + ┬º┬ºpop());
  97.                addr2099:
  98.                ┬º┬ºpush(true);
  99.                if(eval("\x01") == 196)
  100.                {
  101.                   set("\x01",eval("\x01") + 670);
  102.                   ┬º┬ºgoto(addr2099);
  103.                   ┬º┬ºpush(true);
  104.                }
  105.                if(eval("\x01") == 937)
  106.                {
  107.                   set("\x01",eval("\x01") - 375);
  108.                   ┬º┬ºgoto(addr2099);
  109.                   ┬º┬ºpush(true);
  110.                }
  111.                if(eval("\x01") == 562)
  112.                {
  113.                   set("\x01",eval("\x01") + 102);
  114.                   if(!┬º┬ºpop())
  115.                   {
  116.                      addr2150:
  117.                      ┬º┬ºgoto(addr2099);
  118.                   }
  119.                   set("\x01",eval("\x01") - 18);
  120.                   ┬º┬ºgoto(addr2150);
  121.                }
  122.                if(eval("\x01") != 960)
  123.                {
  124.                   if(eval("\x01") != 991)
  125.                   {
  126.                      if(eval("\x01") == 102)
  127.                      {
  128.                         set("\x01",eval("\x01") + 765);
  129.                         ┬º┬ºgoto(addr2099);
  130.                      }
  131.                      if(eval("\x01") == 605)
  132.                      {
  133.                         set("\x01",eval("\x01") - 450);
  134.                         ┬º┬ºgoto(addr2099);
  135.                      }
  136.                      if(eval("\x01") == 235)
  137.                      {
  138.                         set("\x01",eval("\x01") + 675);
  139.                         ┬º┬ºgoto(addr2099);
  140.                      }
  141.                      if(eval("\x01") == 155)
  142.                      {
  143.                         ┬º┬ºgoto(addr2228);
  144.                         ┬º┬ºpush("\x01");
  145.                         ┬º┬ºpush(eval("\x01"));
  146.                         ┬º┬ºpush(230);
  147.                      }
  148.                      if(eval("\x01") == 584)
  149.                      {
  150.                         set("\x01",eval("\x01") + 67);
  151.                         ┬º┬ºgoto(addr2228);
  152.                      }
  153.                      if(eval("\x01") == 338)
  154.                      {
  155.                         set("\x01",eval("\x01") + 599);
  156.                         ┬º┬ºgoto(addr2228);
  157.                      }
  158.                      if(eval("\x01") == 974)
  159.                      {
  160.                         set("\x01",eval("\x01") - 119);
  161.                         ┬º┬ºgoto(addr2228);
  162.                      }
  163.                      if(eval("\x01") == 651)
  164.                      {
  165.                         set("\x01",eval("\x01") - 397);
  166.                         ┬º┬ºgoto(addr2228);
  167.                         ┬º┬ºpush(true);
  168.                      }
  169.                      if(eval("\x01") == 85)
  170.                      {
  171.                         set("\x01",eval("\x01") + 770);
  172.                         ┬º┬ºgoto(addr2228);
  173.                      }
  174.                      if(eval("\x01") == 866)
  175.                      {
  176.                         set("\x01",eval("\x01") + 94);
  177.                         if(!┬º┬ºpop())
  178.                         {
  179.                            addr2320:
  180.                            ┬º┬ºgoto(addr2228);
  181.                         }
  182.                         set("\x01",eval("\x01") - 622);
  183.                         ┬º┬ºgoto(addr2320);
  184.                      }
  185.                      if(eval("\x01") != 855)
  186.                      {
  187.                         if(eval("\x01") == 751)
  188.                         {
  189.                            set("\x01",eval("\x01") - 100);
  190.                            ┬º┬ºgoto(addr2228);
  191.                         }
  192.                         if(eval("\x01") != 95)
  193.                         {
  194.                            if(eval("\x01") != 141)
  195.                            {
  196.                               if(eval("\x01") != 704)
  197.                               {
  198.                                  if(eval("\x01") != 680)
  199.                                  {
  200.                                     if(eval("\x01") == 481)
  201.                                     {
  202.                                        set("\x01",eval("\x01") + 58);
  203.                                        ┬º┬ºgoto(addr2228);
  204.                                     }
  205.                                     if(eval("\x01") == 254)
  206.                                     {
  207.                                        set("\x01",eval("\x01") + 443);
  208.                                        if(!┬º┬ºpop())
  209.                                        {
  210.                                           addr2436:
  211.                                           ┬º┬ºgoto(addr2228);
  212.                                        }
  213.                                        set("\x01",eval("\x01") - 2);
  214.                                        ┬º┬ºgoto(addr2436);
  215.                                     }
  216.                                     if(eval("\x01") == 326)
  217.                                     {
  218.                                        set("\x01",eval("\x01") + 213);
  219.                                        ┬º┬ºgoto(addr2228);
  220.                                     }
  221.                                     if(eval("\x01") == 859)
  222.                                     {
  223.                                        set("\x01",eval("\x01") - 179);
  224.                                        if(!┬º┬ºpop())
  225.                                        {
  226.                                           addr2471:
  227.                                           ┬º┬ºgoto(addr2228);
  228.                                        }
  229.                                        set("\x01",eval("\x01") + 71);
  230.                                        ┬º┬ºgoto(addr2471);
  231.                                     }
  232.                                     if(eval("\x01") == 664)
  233.                                     {
  234.                                        set("\x01",eval("\x01") - 18);
  235.                                        addr1809:
  236.                                        if(eval("\x01") == 369)
  237.                                        {
  238.                                           set("\x01",eval("\x01") + 60);
  239.                                           if(!┬º┬ºpop())
  240.                                           {
  241.                                              addr1273:
  242.                                              if(eval("\x01") == 767)
  243.                                              {
  244.                                                 set("\x01",eval("\x01") - 421);
  245.                                                 ┬º┬ºgoto(addr1273);
  246.                                                 ┬º┬ºpush(true);
  247.                                              }
  248.                                              if(eval("\x01") != 192)
  249.                                              {
  250.                                                 if(eval("\x01") == 846)
  251.                                                 {
  252.                                                    set("\x01",eval("\x01") - 803);
  253.                                                    ┬º┬ºgoto(addr1273);
  254.                                                 }
  255.                                                 if(eval("\x01") == 538)
  256.                                                 {
  257.                                                    set("\x01",eval("\x01") - 471);
  258.                                                    ┬º┬ºgoto(addr1273);
  259.                                                 }
  260.                                                 if(eval("\x01") == 610)
  261.                                                 {
  262.                                                    set("\x01",eval("\x01") + 208);
  263.                                                    if(!┬º┬ºpop())
  264.                                                    {
  265.                                                       addr1351:
  266.                                                       ┬º┬ºgoto(addr1273);
  267.                                                    }
  268.                                                    set("\x01",eval("\x01") - 157);
  269.                                                    ┬º┬ºgoto(addr1351);
  270.                                                 }
  271.                                                 if(eval("\x01") == 449)
  272.                                                 {
  273.                                                    set("\x01",eval("\x01") + 219);
  274.                                                    if(!┬º┬ºpop())
  275.                                                    {
  276.                                                       addr1372:
  277.                                                       ┬º┬ºgoto(addr1273);
  278.                                                    }
  279.                                                    set("\x01",eval("\x01") - 201);
  280.                                                    ┬º┬ºgoto(addr1372);
  281.                                                 }
  282.                                                 if(eval("\x01") == 346)
  283.                                                 {
  284.                                                    set("\x01",eval("\x01") - 248);
  285.                                                    if(!┬º┬ºpop())
  286.                                                    {
  287.                                                       addr1393:
  288.                                                       ┬º┬ºgoto(addr1273);
  289.                                                    }
  290.                                                    set("\x01",eval("\x01") + 438);
  291.                                                    ┬º┬ºgoto(addr1393);
  292.                                                 }
  293.                                                 if(eval("\x01") == 490)
  294.                                                 {
  295.                                                    set("\x01",eval("\x01") + 186);
  296.                                                    if(!┬º┬ºpop())
  297.                                                    {
  298.                                                       addr1414:
  299.                                                       ┬º┬ºgoto(addr1273);
  300.                                                    }
  301.                                                    set("\x01",eval("\x01") - 435);
  302.                                                    ┬º┬ºgoto(addr1414);
  303.                                                 }
  304.                                                 if(eval("\x01") == 987)
  305.                                                 {
  306.                                                    set("\x01",eval("\x01") - 795);
  307.                                                    ┬º┬ºgoto(addr1273);
  308.                                                 }
  309.                                                 if(eval("\x01") == 335)
  310.                                                 {
  311.                                                    set("\x01",eval("\x01") + 391);
  312.                                                    ┬º┬ºgoto(addr1273);
  313.                                                 }
  314.                                                 if(eval("\x01") != 653)
  315.                                                 {
  316.                                                    if(eval("\x01") == 986)
  317.                                                    {
  318.                                                       set("\x01",eval("\x01") - 919);
  319.                                                       ┬º┬ºgoto(addr1273);
  320.                                                    }
  321.                                                    if(eval("\x01") == 536)
  322.                                                    {
  323.                                                       set("\x01",eval("\x01") + 190);
  324.                                                       ┬º┬ºgoto(addr1273);
  325.                                                    }
  326.                                                    if(eval("\x01") == 936)
  327.                                                    {
  328.                                                       set("\x01",eval("\x01") - 309);
  329.                                                       ┬º┬ºgoto(addr1273);
  330.                                                    }
  331.                                                    if(eval("\x01") == 726)
  332.                                                    {
  333.                                                       set("\x01",eval("\x01") - 116);
  334.                                                       ┬º┬ºgoto(addr1273);
  335.                                                       ┬º┬ºpush(true);
  336.                                                    }
  337.                                                    if(eval("\x01") == 273)
  338.                                                    {
  339.                                                       set("\x01",eval("\x01") + 257);
  340.                                                       ┬º┬ºgoto(addr1273);
  341.                                                       ┬º┬ºpush(true);
  342.                                                    }
  343.                                                    if(eval("\x01") == 712)
  344.                                                    {
  345.                                                       set("\x01",eval("\x01") - 439);
  346.                                                       ┬º┬ºgoto(addr1273);
  347.                                                    }
  348.                                                    if(eval("\x01") != 676)
  349.                                                    {
  350.                                                       if(eval("\x01") != 98)
  351.                                                       {
  352.                                                          if(eval("\x01") != 153)
  353.                                                          {
  354.                                                             if(eval("\x01") == 818)
  355.                                                             {
  356.                                                                set("\x01",eval("\x01") - 157);
  357.                                                                addr3962:
  358.                                                                set(┬º┬ºpop(),┬º┬ºpop() - new ┬º\┬º\┬ºpop() > \┬º\┬ºpop()┬º());
  359.                                                                if(!┬º┬ºpop())
  360.                                                                {
  361.                                                                   addr3972:
  362.                                                                   ┬º┬ºgoto(addr3305);
  363.                                                                }
  364.                                                                set("\x01",eval("\x01") - 50);
  365.                                                                ┬º┬ºgoto(addr3972);
  366.                                                             }
  367.                                                             if(eval("\x01") == 530)
  368.                                                             {
  369.                                                                set("\x01",eval("\x01") - 377);
  370.                                                                if(!┬º┬ºpop())
  371.                                                                {
  372.                                                                   addr1611:
  373.                                                                   ┬º┬ºgoto(addr1273);
  374.                                                                }
  375.                                                                set("\x01",eval("\x01") + 385);
  376.                                                                ┬º┬ºgoto(addr1611);
  377.                                                             }
  378.                                                             if(eval("\x01") == 279)
  379.                                                             {
  380.                                                                set("\x01",eval("\x01") - 87);
  381.                                                                ┬º┬ºgoto(addr1273);
  382.                                                             }
  383.                                                             if(eval("\x01") == 241)
  384.                                                             {
  385.                                                                set("\x01",eval("\x01") - 198);
  386.                                                                ┬º┬ºgoto(addr1273);
  387.                                                             }
  388.                                                             if(eval("\x01") == 661)
  389.                                                             {
  390.                                                                set("\x01",eval("\x01") - 615);
  391.                                                                ┬º┬ºgoto(addr1273);
  392.                                                             }
  393.                                                             if(eval("\x01") == 2)
  394.                                                             {
  395.                                                                set("\x01",eval("\x01") + 651);
  396.                                                                if(!┬º┬ºpop())
  397.                                                                {
  398.                                                                   addr1672:
  399.                                                                   ┬º┬ºgoto(addr1273);
  400.                                                                }
  401.                                                                set("\x01",eval("\x01") + 334);
  402.                                                                ┬º┬ºgoto(addr1672);
  403.                                                             }
  404.                                                             if(eval("\x01") == 22)
  405.                                                             {
  406.                                                                set("\x01",eval("\x01") + 613);
  407.                                                                ┬º┬ºgoto(addr1273);
  408.                                                             }
  409.                                                             if(eval("\x01") == 67)
  410.                                                             {
  411.                                                                set("\x01",eval("\x01") + 870);
  412.                                                                ┬º┬ºgoto(addr1273);
  413.                                                                ┬º┬ºpush(true);
  414.                                                             }
  415.                                                             if(eval("\x01") == 627)
  416.                                                             {
  417.                                                                set("\x01",eval("\x01") - 625);
  418.                                                                ┬º┬ºgoto(addr1273);
  419.                                                                ┬º┬ºpush(true);
  420.                                                             }
  421.                                                             if(eval("\x01") == 635)
  422.                                                             {
  423.                                                                set("\x01",eval("\x01") - 145);
  424.                                                                ┬º┬ºgoto(addr1273);
  425.                                                                ┬º┬ºpush(true);
  426.                                                             }
  427.                                                             if(eval("\x01") == 495)
  428.                                                             {
  429.                                                                set("\x01",eval("\x01") - 449);
  430.                                                                ┬º┬ºgoto(addr1273);
  431.                                                             }
  432.                                                             if(eval("\x01") == 86)
  433.                                                             {
  434.                                                                set("\x01",eval("\x01") + 549);
  435.                                                                ┬º┬ºgoto(addr1273);
  436.                                                             }
  437.                                                             if(eval("\x01") == 467)
  438.                                                             {
  439.                                                                set("\x01",eval("\x01") + 160);
  440.                                                                ┬º┬ºgoto(addr1273);
  441.                                                             }
  442.                                                             if(eval("\x01") == 46)
  443.                                                             {
  444.                                                                set("\x01",eval("\x01") + 323);
  445.                                                                ┬º┬ºgoto(addr1273);
  446.                                                                ┬º┬ºpush(true);
  447.                                                             }
  448.                                                             if(eval("\x01") == 123)
  449.                                                             {
  450.                                                                set("\x01",eval("\x01") + 150);
  451.                                                                ┬º┬ºgoto(addr1273);
  452.                                                             }
  453.                                                             if(eval("\x01") != 668)
  454.                                                             {
  455.                                                                ┬º┬ºgoto(addr1809);
  456.                                                             }
  457.                                                             set("\x01",eval("\x01") - 201);
  458.                                                             ┬º┬ºgoto(addr4519);
  459.                                                          }
  460.                                                          set("\x01",eval("\x01") + 385);
  461.                                                          ┬º┬ºgoto(addr4519);
  462.                                                       }
  463.                                                       set("\x01",eval("\x01") + 438);
  464.                                                       addr109:
  465.                                                       if(┬º┬ºpop())
  466.                                                       {
  467.                                                          set("\x01",eval("\x01") - 228);
  468.                                                          ┬º┬ºgoto(addr18);
  469.                                                       }
  470.                                                       if(eval("\x01") != 888)
  471.                                                       {
  472.                                                          if(eval("\x01") != 74)
  473.                                                          {
  474.                                                             if(eval("\x01") == 967)
  475.                                                             {
  476.                                                                set("\x01",eval("\x01") + 32);
  477.                                                                addr18:
  478.                                                                if(eval("\x01") == 153)
  479.                                                                {
  480.                                                                   set("\x01",eval("\x01") + 29);
  481.                                                                   ┬º┬ºgoto(addr18);
  482.                                                                   ┬º┬ºpush(true);
  483.                                                                }
  484.                                                                if(eval("\x01") != 236)
  485.                                                                {
  486.                                                                   if(eval("\x01") == 710)
  487.                                                                   {
  488.                                                                      set("\x01",eval("\x01") + 257);
  489.                                                                      ┬º┬ºgoto(addr18);
  490.                                                                   }
  491.                                                                   if(eval("\x01") == 999)
  492.                                                                   {
  493.                                                                      set("\x01",eval("\x01") - 274);
  494.                                                                      if(!┬º┬ºpop())
  495.                                                                      {
  496.                                                                         addr83:
  497.                                                                         ┬º┬ºgoto(addr18);
  498.                                                                      }
  499.                                                                      set("\x01",eval("\x01") - 306);
  500.                                                                      ┬º┬ºgoto(addr83);
  501.                                                                   }
  502.                                                                   if(eval("\x01") == 182)
  503.                                                                   {
  504.                                                                      set("\x01",eval("\x01") + 706);
  505.                                                                      if(!┬º┬ºpop())
  506.                                                                      {
  507.                                                                         addr104:
  508.                                                                         ┬º┬ºgoto(addr18);
  509.                                                                      }
  510.                                                                      set("\x01",eval("\x01") - 627);
  511.                                                                      ┬º┬ºgoto(addr104);
  512.                                                                   }
  513.                                                                   ┬º┬ºgoto(addr109);
  514.                                                                   ┬º┬ºpush(eval("\x01") == 464);
  515.                                                                }
  516.                                                                set("\x01",eval("\x01") - 12);
  517.                                                                stop();
  518.                                                                addr4519:
  519.                                                                ┬º┬ºpush(true);
  520.                                                             }
  521.                                                             if(eval("\x01") != 725)
  522.                                                             {
  523.                                                                if(eval("\x01") == 18)
  524.                                                                {
  525.                                                                   set("\x01",eval("\x01") + 56);
  526.                                                                   if(!┬º┬ºpop())
  527.                                                                   {
  528.                                                                      addr191:
  529.                                                                      ┬º┬ºgoto(addr18);
  530.                                                                   }
  531.                                                                   set("\x01",eval("\x01") + 390);
  532.                                                                   ┬º┬ºgoto(addr191);
  533.                                                                }
  534.                                                                if(eval("\x01") == 550)
  535.                                                                {
  536.                                                                   set("\x01",eval("\x01") - 532);
  537.                                                                   ┬º┬ºgoto(addr18);
  538.                                                                   ┬º┬ºpush(true);
  539.                                                                }
  540.                                                                if(eval("\x01") == 827)
  541.                                                                {
  542.                                                                   set("\x01",eval("\x01") - 591);
  543.                                                                   ┬º┬ºgoto(addr18);
  544.                                                                }
  545.                                                                if(eval("\x01") == 747)
  546.                                                                {
  547.                                                                   set("\x01",eval("\x01") - 197);
  548.                                                                   ┬º┬ºgoto(addr18);
  549.                                                                }
  550.                                                                if(eval("\x01") == 261)
  551.                                                                {
  552.                                                                   set("\x01",eval("\x01") + 706);
  553.                                                                   ┬º┬ºgoto(addr18);
  554.                                                                }
  555.                                                                if(eval("\x01") != 224)
  556.                                                                {
  557.                                                                   if(eval("\x01") == 419)
  558.                                                                   {
  559.                                                                      set("\x01",eval("\x01") + 131);
  560.                                                                      ┬º┬ºgoto(addr18);
  561.                                                                   }
  562.                                                                   ┬º┬ºgoto(addr4519);
  563.                                                                }
  564.                                                                set("\x01",eval("\x01") - 224);
  565.                                                                ┬º┬ºgoto(addr4519);
  566.                                                             }
  567.                                                             set("\x01",eval("\x01") - 306);
  568.                                                             ┬º┬ºgoto(addr4519);
  569.                                                          }
  570.                                                          set("\x01",eval("\x01") + 390);
  571.                                                          ┬º┬ºgoto(addr4519);
  572.                                                          ┬º┬ºpush(typeof (┬º┬ºpop() gt length(┬º┬ºpop()))());
  573.                                                       }
  574.                                                       set("\x01",eval("\x01") - 627);
  575.                                                       ┬º┬ºgoto(addr4519);
  576.                                                    }
  577.                                                    set("\x01",eval("\x01") - 435);
  578.                                                    ┬º┬ºgoto(addr4519);
  579.                                                    ┬º┬ºpush(┬º┬ºpop() >> ┬º┬ºpop());
  580.                                                 }
  581.                                                 set("\x01",eval("\x01") + 334);
  582.                                                 ┬º┬ºgoto(addr4519);
  583.                                              }
  584.                                              set("\x01",eval("\x01") + 785);
  585.                                              stop();
  586.                                              ┬º┬ºgoto(addr4519);
  587.                                              addr1829:
  588.                                           }
  589.                                           set("\x01",eval("\x01") - 306);
  590.                                           ┬º┬ºgoto(addr1829);
  591.                                        }
  592.                                        if(eval("\x01") == 937)
  593.                                        {
  594.                                           set("\x01",eval("\x01") - 753);
  595.                                           if(!┬º┬ºpop())
  596.                                           {
  597.                                              addr1850:
  598.                                              ┬º┬ºgoto(addr1273);
  599.                                           }
  600.                                           set("\x01",eval("\x01") - 98);
  601.                                           ┬º┬ºgoto(addr1850);
  602.                                        }
  603.                                        if(eval("\x01") == 43)
  604.                                        {
  605.                                           set("\x01",eval("\x01") + 406);
  606.                                           ┬º┬ºgoto(addr1273);
  607.                                           ┬º┬ºpush(true);
  608.                                        }
  609.                                        if(eval("\x01") == 429)
  610.                                        {
  611.                                           set("\x01",eval("\x01") - 306);
  612.                                        }
  613.                                        else if(eval("\x01") == 184)
  614.                                        {
  615.                                           set("\x01",eval("\x01") - 98);
  616.                                           ┬º┬ºgoto(addr4519);
  617.                                           ┬º┬ºpush(random(┬º┬ºpop()));
  618.                                        }
  619.                                        else
  620.                                        {
  621.                                           if(eval("\x01") == 977)
  622.                                           {
  623.                                              set("\x01",eval("\x01") - 977);
  624.                                           }
  625.                                           ┬º┬ºgoto(addr4519);
  626.                                        }
  627.                                        ┬º┬ºgoto(addr4519);
  628.                                     }
  629.                                     if(eval("\x01") == 25)
  630.                                     {
  631.                                        set("\x01",eval("\x01") + 912);
  632.                                        ┬º┬ºgoto(addr2228);
  633.                                     }
  634.                                     if(eval("\x01") == 165)
  635.                                     {
  636.                                        set("\x01",eval("\x01") + 745);
  637.                                        ┬º┬ºgoto(addr2228);
  638.                                     }
  639.                                     if(eval("\x01") == 352)
  640.                                     {
  641.                                        set("\x01",eval("\x01") - 211);
  642.                                        if(!┬º┬ºpop())
  643.                                        {
  644.                                           addr2533:
  645.                                           ┬º┬ºgoto(addr2228);
  646.                                        }
  647.                                        set("\x01",eval("\x01") + 94);
  648.                                        ┬º┬ºgoto(addr2533);
  649.                                     }
  650.                                     if(eval("\x01") == 935)
  651.                                     {
  652.                                        set("\x01",eval("\x01") - 231);
  653.                                        if(!┬º┬ºpop())
  654.                                        {
  655.                                           addr2554:
  656.                                           ┬º┬ºgoto(addr2228);
  657.                                        }
  658.                                        set("\x01",eval("\x01") + 270);
  659.                                        ┬º┬ºgoto(addr2554);
  660.                                     }
  661.                                     if(eval("\x01") == 646)
  662.                                     {
  663.                                        set("\x01",eval("\x01") + 183);
  664.                                        ┬º┬ºgoto(addr2228);
  665.                                     }
  666.                                     if(eval("\x01") == 3)
  667.                                     {
  668.                                        set("\x01",eval("\x01") + 826);
  669.                                        ┬º┬ºgoto(addr2228);
  670.                                     }
  671.                                     if(eval("\x01") == 867)
  672.                                     {
  673.                                        set("\x01",eval("\x01") + 68);
  674.                                        ┬º┬ºgoto(addr2228);
  675.                                        ┬º┬ºpush(true);
  676.                                     }
  677.                                     if(eval("\x01") == 910)
  678.                                     {
  679.                                        set("\x01",eval("\x01") - 668);
  680.                                        ┬º┬ºgoto(addr2228);
  681.                                        ┬º┬ºpush(true);
  682.                                     }
  683.                                     if(eval("\x01") == 539)
  684.                                     {
  685.                                        set("\x01",eval("\x01") + 320);
  686.                                        ┬º┬ºgoto(addr2228);
  687.                                        ┬º┬ºpush(true);
  688.                                     }
  689.                                     if(eval("\x01") == 242)
  690.                                     {
  691.                                        set("\x01",eval("\x01") + 749);
  692.                                        if(!┬º┬ºpop())
  693.                                        {
  694.                                           addr2645:
  695.                                           ┬º┬ºgoto(addr2228);
  696.                                        }
  697.                                        set("\x01",eval("\x01") - 371);
  698.                                        ┬º┬ºgoto(addr2645);
  699.                                     }
  700.                                     if(eval("\x01") == 620)
  701.                                     {
  702.                                        set("\x01",eval("\x01") - 465);
  703.                                        ┬º┬ºgoto(addr2228);
  704.                                     }
  705.                                     if(eval("\x01") == 829)
  706.                                     {
  707.                                        set("\x01",eval("\x01") - 477);
  708.                                        ┬º┬ºgoto(addr2228);
  709.                                        ┬º┬ºpush(true);
  710.                                     }
  711.                                     if(eval("\x01") == 385)
  712.                                     {
  713.                                        set("\x01",eval("\x01") + 517);
  714.                                        if(!┬º┬ºpop())
  715.                                        {
  716.                                           addr2695:
  717.                                           ┬º┬ºgoto(addr2228);
  718.                                        }
  719.                                        set("\x01",eval("\x01") - 421);
  720.                                        ┬º┬ºgoto(addr2695);
  721.                                     }
  722.                                     if(eval("\x01") != 697)
  723.                                     {
  724.                                        if(eval("\x01") != 902)
  725.                                        {
  726.                                           if(eval("\x01") == 695)
  727.                                           {
  728.                                              set("\x01",eval("\x01") + 172);
  729.                                              ┬º┬ºgoto(addr2228);
  730.                                           }
  731.                                           ┬º┬ºgoto(addr4519);
  732.                                        }
  733.                                        set("\x01",eval("\x01") - 421);
  734.                                        if(┬º┬ºpop())
  735.                                        {
  736.                                           set("\x01",eval("\x01") - 566);
  737.                                           stop();
  738.                                        }
  739.                                        else if(eval("\x01") == 20)
  740.                                        {
  741.                                           set("\x01",eval("\x01") - 20);
  742.                                        }
  743.                                        ┬º┬ºgoto(addr4519);
  744.                                     }
  745.                                     set("\x01",eval("\x01") - 2);
  746.                                     ┬º┬ºgoto(addr4519);
  747.                                  }
  748.                                  set("\x01",eval("\x01") + 71);
  749.                                  ┬º┬ºgoto(addr4519);
  750.                               }
  751.                               set("\x01",eval("\x01") + 270);
  752.                               ┬º┬ºgoto(addr4519);
  753.                            }
  754.                            set("\x01",eval("\x01") + 94);
  755.                            ┬º┬ºgoto(addr4519);
  756.                            ┬º┬ºpush(┬º┬ºpop() >>> ┬º┬ºpop());
  757.                            addr2376:
  758.                         }
  759.                         set("\x01",eval("\x01") - 95);
  760.                         ┬º┬ºgoto(addr4519);
  761.                      }
  762.                      set("\x01",eval("\x01") - 760);
  763.                      stop();
  764.                      ┬º┬ºgoto(addr4519);
  765.                   }
  766.                   set("\x01",eval("\x01") - 371);
  767.                   ┬º┬ºgoto(addr4519);
  768.                }
  769.                set("\x01",eval("\x01") - 622);
  770.                ┬º┬ºgoto(addr4519);
  771.                ┬º┬ºpush(┬º┬ºpop() add ┬º┬ºpop());
  772.             }
  773.             if(eval("\x01") != 817)
  774.             {
  775.                if(eval("\x01") == 29)
  776.                {
  777.                   set("\x01",eval("\x01") + 59);
  778.                   ┬º┬ºgoto(addr1273);
  779.                }
  780.                if(eval("\x01") == 674)
  781.                {
  782.                   set("\x01",eval("\x01") - 45);
  783.                   ┬º┬ºgoto(addr3305);
  784.                }
  785.                if(eval("\x01") != 769)
  786.                {
  787.                   if(eval("\x01") == 452)
  788.                   {
  789.                      set("\x01",eval("\x01") + 183);
  790.                      ┬º┬ºgoto(addr3305);
  791.                   }
  792.                   if(eval("\x01") == 206)
  793.                   {
  794.                      set("\x01",eval("\x01") + 239);
  795.                      ┬º┬ºgoto(addr3305);
  796.                   }
  797.                   if(eval("\x01") == 897)
  798.                   {
  799.                      set("\x01",eval("\x01") - 262);
  800.                      ┬º┬ºgoto(addr3305);
  801.                   }
  802.                   if(eval("\x01") == 515)
  803.                   {
  804.                      set("\x01",eval("\x01") + 259);
  805.                      ┬º┬ºgoto(addr3305);
  806.                      ┬º┬ºpush(true);
  807.                   }
  808.                   if(eval("\x01") == 635)
  809.                   {
  810.                      set("\x01",eval("\x01") + 245);
  811.                      ┬º┬ºgoto(addr3305);
  812.                      ┬º┬ºpush(true);
  813.                   }
  814.                   if(eval("\x01") == 602)
  815.                   {
  816.                      set("\x01",eval("\x01") + 11);
  817.                      if(!┬º┬ºpop())
  818.                      {
  819.                         addr3564:
  820.                         ┬º┬ºgoto(addr3305);
  821.                      }
  822.                      set("\x01",eval("\x01") - 597);
  823.                      ┬º┬ºgoto(addr3564);
  824.                   }
  825.                   if(eval("\x01") == 88)
  826.                   {
  827.                      set("\x01",eval("\x01") + 427);
  828.                      ┬º┬ºgoto(addr3305);
  829.                   }
  830.                   if(eval("\x01") == 469)
  831.                   {
  832.                      set("\x01",eval("\x01") + 133);
  833.                      ┬º┬ºgoto(addr3305);
  834.                      ┬º┬ºpush(true);
  835.                   }
  836.                   if(eval("\x01") != 270)
  837.                   {
  838.                      if(eval("\x01") == 774)
  839.                      {
  840.                         set("\x01",eval("\x01") - 504);
  841.                         if(!┬º┬ºpop())
  842.                         {
  843.                            addr3625:
  844.                            ┬º┬ºgoto(addr3305);
  845.                         }
  846.                         set("\x01",eval("\x01") - 266);
  847.                         ┬º┬ºgoto(addr3625);
  848.                      }
  849.                      if(eval("\x01") == 880)
  850.                      {
  851.                         set("\x01",eval("\x01") - 740);
  852.                         if(!┬º┬ºpop())
  853.                         {
  854.                            addr3646:
  855.                            ┬º┬ºgoto(addr3305);
  856.                         }
  857.                         set("\x01",eval("\x01") + 74);
  858.                         ┬º┬ºgoto(addr3646);
  859.                      }
  860.                      if(eval("\x01") == 165)
  861.                      {
  862.                         set("\x01",eval("\x01") + 311);
  863.                         if(!┬º┬ºpop())
  864.                         {
  865.                            addr3667:
  866.                            ┬º┬ºgoto(addr3305);
  867.                         }
  868.                         set("\x01",eval("\x01") + 100);
  869.                         ┬º┬ºgoto(addr3667);
  870.                      }
  871.                      if(eval("\x01") == 375)
  872.                      {
  873.                         set("\x01",eval("\x01") + 140);
  874.                         ┬º┬ºgoto(addr3305);
  875.                      }
  876.                      if(eval("\x01") == 576)
  877.                      {
  878.                         set("\x01",eval("\x01") - 184);
  879.                         ┬º┬ºgoto(addr3305);
  880.                      }
  881.                      if(eval("\x01") == 629)
  882.                      {
  883.                         ┬º┬ºgoto(addr3704);
  884.                         ┬º┬ºpush("\x01");
  885.                         ┬º┬ºpush(eval("\x01"));
  886.                      }
  887.                      if(eval("\x01") == 731)
  888.                      {
  889.                         set("\x01",eval("\x01") + 24);
  890.                         ┬º┬ºgoto(addr3704);
  891.                      }
  892.                      if(eval("\x01") != 140)
  893.                      {
  894.                         if(eval("\x01") == 392)
  895.                         {
  896.                            set("\x01",eval("\x01") + 44);
  897.                            ┬º┬ºgoto(addr3704);
  898.                            ┬º┬ºpush(true);
  899.                         }
  900.                         if(eval("\x01") == 11)
  901.                         {
  902.                            set("\x01",eval("\x01") + 827);
  903.                            if(!┬º┬ºpop())
  904.                            {
  905.                               addr3770:
  906.                               ┬º┬ºgoto(addr3704);
  907.                            }
  908.                            set("\x01",eval("\x01") - 521);
  909.                            ┬º┬ºgoto(addr3770);
  910.                         }
  911.                         addr3775:
  912.                         if(eval("\x01") == 965)
  913.                         {
  914.                            set("\x01",eval("\x01") - 573);
  915.                            ┬º┬ºgoto(addr3704);
  916.                         }
  917.                         if(eval("\x01") == 554)
  918.                         {
  919.                            set("\x01",eval("\x01") + 168);
  920.                            ┬º┬ºgoto(addr3704);
  921.                            ┬º┬ºpush(true);
  922.                         }
  923.                         if(eval("\x01") == 317)
  924.                         {
  925.                            set("\x01",eval("\x01") + 152);
  926.                            ┬º┬ºgoto(addr3704);
  927.                         }
  928.                         if(eval("\x01") == 583)
  929.                         {
  930.                            set("\x01",eval("\x01") + 172);
  931.                            ┬º┬ºgoto(addr3704);
  932.                         }
  933.                         if(eval("\x01") == 214)
  934.                         {
  935.                            set("\x01",eval("\x01") + 340);
  936.                            ┬º┬ºgoto(addr3704);
  937.                         }
  938.                         if(eval("\x01") == 524)
  939.                         {
  940.                            set("\x01",eval("\x01") - 92);
  941.                            ┬º┬ºgoto(addr3704);
  942.                         }
  943.                         if(eval("\x01") == 432)
  944.                         {
  945.                            set("\x01",eval("\x01") - 300);
  946.                            ┬º┬ºgoto(addr3704);
  947.                            ┬º┬ºpush(true);
  948.                         }
  949.                         if(eval("\x01") == 436)
  950.                         {
  951.                            set("\x01",eval("\x01") - 407);
  952.                            if(!┬º┬ºpop())
  953.                            {
  954.                               addr3886:
  955.                               ┬º┬ºgoto(addr3704);
  956.                            }
  957.                            set("\x01",eval("\x01") + 59);
  958.                            ┬º┬ºgoto(addr3886);
  959.                         }
  960.                         if(eval("\x01") == 597)
  961.                         {
  962.                            set("\x01",eval("\x01") - 43);
  963.                            ┬º┬ºgoto(addr3704);
  964.                         }
  965.                         if(eval("\x01") == 132)
  966.                         {
  967.                            set("\x01",eval("\x01") + 637);
  968.                            if(!┬º┬ºpop())
  969.                            {
  970.                               addr3921:
  971.                               ┬º┬ºgoto(addr3704);
  972.                            }
  973.                            set("\x01",eval("\x01") - 186);
  974.                            ┬º┬ºgoto(addr3921);
  975.                         }
  976.                         if(eval("\x01") != 567)
  977.                         {
  978.                            if(eval("\x01") == 755)
  979.                            {
  980.                               set("\x01",eval("\x01") - 744);
  981.                               ┬º┬ºgoto(addr3704);
  982.                               ┬º┬ºpush(true);
  983.                            }
  984.                            if(eval("\x01") == 722)
  985.                            {
  986.                               ┬º┬ºgoto(addr3962);
  987.                               ┬º┬ºpush("\x01");
  988.                               ┬º┬ºpush(eval("\x01"));
  989.                               ┬º┬ºpush(155);
  990.                            }
  991.                            if(eval("\x01") == 16)
  992.                            {
  993.                               set("\x01",eval("\x01") + 429);
  994.                               ┬º┬ºgoto(addr3704);
  995.                            }
  996.                            if(eval("\x01") == 445)
  997.                            {
  998.                               set("\x01",eval("\x01") + 32);
  999.                               stop();
  1000.                            }
  1001.                            else if(eval("\x01") == 477)
  1002.                            {
  1003.                               set("\x01",eval("\x01") - 477);
  1004.                            }
  1005.                            ┬º┬ºgoto(addr4519);
  1006.                         }
  1007.                         set("\x01",eval("\x01") - 50);
  1008.                         ┬º┬ºgoto(addr2376);
  1009.                      }
  1010.                      set("\x01",eval("\x01") + 74);
  1011.                      ┬º┬ºgoto(addr4519);
  1012.                   }
  1013.                   set("\x01",eval("\x01") - 266);
  1014.                   ┬º┬ºgoto(addr4519);
  1015.                }
  1016.                set("\x01",eval("\x01") - 186);
  1017.                ┬º┬ºgoto(addr4519);
  1018.                ┬º┬ºpush(new ┬ºmbchr(\┬º\┬ºpop())┬º());
  1019.             }
  1020.             set("\x01",eval("\x01") - 365);
  1021.             ┬º┬ºgoto(addr4519);
  1022.          }
  1023.          set("\x01",eval("\x01") + 100);
  1024.          ┬º┬ºgoto(addr4519);
  1025.       }
  1026.       set("\x01",eval("\x01") - 597);
  1027.    }
  1028.    else if(eval("\x01") == 867)
  1029.    {
  1030.       set("\x01",eval("\x01") - 178);
  1031.    }
  1032.    else
  1033.    {
  1034.       if(eval("\x01") == 8)
  1035.       {
  1036.          set("\x01",eval("\x01") + 897);
  1037.          if(┬º┬ºpop())
  1038.          {
  1039.             set("\x01",eval("\x01") - 72);
  1040.          }
  1041.          continue;
  1042.       }
  1043.       if(eval("\x01") == 689)
  1044.       {
  1045.          set("\x01",eval("\x01") - 227);
  1046.          continue;
  1047.       }
  1048.       if(eval("\x01") == 786)
  1049.       {
  1050.          set("\x01",eval("\x01") - 444);
  1051.          while(true)
  1052.          {
  1053.             if(eval(┬º┬ºpop()) == 764)
  1054.             {
  1055.                set("\x01",eval("\x01") - 611);
  1056.                continue;
  1057.             }
  1058.             if(eval("\x01") == 482)
  1059.             {
  1060.                set("\x01",eval("\x01") + 478);
  1061.                continue;
  1062.             }
  1063.             if(eval("\x01") == 573)
  1064.             {
  1065.                set("\x01",eval("\x01") + 394);
  1066.                if(┬º┬ºpop())
  1067.                {
  1068.                   set("\x01",eval("\x01") - 163);
  1069.                }
  1070.                continue;
  1071.             }
  1072.             if(eval("\x01") == 656)
  1073.             {
  1074.                set("\x01",eval("\x01") + 150);
  1075.                ┬º┬ºpush(true);
  1076.                continue;
  1077.             }
  1078.             if(eval("\x01") == 931)
  1079.             {
  1080.                set("\x01",eval("\x01") - 358);
  1081.                ┬º┬ºpush(true);
  1082.                continue;
  1083.             }
  1084.             if(eval("\x01") == 967)
  1085.             {
  1086.                set("\x01",eval("\x01") - 163);
  1087.             }
  1088.             else
  1089.             {
  1090.                if(eval("\x01") == 429)
  1091.                {
  1092.                   set("\x01",eval("\x01") + 227);
  1093.                   continue;
  1094.                }
  1095.                if(eval("\x01") == 466)
  1096.                {
  1097.                   set("\x01",eval("\x01") - 200);
  1098.                   ┬º┬ºpush(ord(┬º┬ºpop()));
  1099.                }
  1100.                else
  1101.                {
  1102.                   if(eval("\x01") == 349)
  1103.                   {
  1104.                      set("\x01",eval("\x01") - 238);
  1105.                      if(┬º┬ºpop())
  1106.                      {
  1107.                         set("\x01",eval("\x01") + 457);
  1108.                      }
  1109.                      continue;
  1110.                   }
  1111.                   if(eval("\x01") == 804)
  1112.                   {
  1113.                      set("\x01",eval("\x01") - 523);
  1114.                      continue;
  1115.                   }
  1116.                   if(eval("\x01") == 154)
  1117.                   {
  1118.                      set("\x01",eval("\x01") + 820);
  1119.                      continue;
  1120.                   }
  1121.                   if(eval("\x01") == 372)
  1122.                   {
  1123.                      set("\x01",eval("\x01") + 559);
  1124.                      continue;
  1125.                   }
  1126.                   if(eval("\x01") == 966)
  1127.                   {
  1128.                      set("\x01",eval("\x01") - 202);
  1129.                   }
  1130.                   else
  1131.                   {
  1132.                      if(eval("\x01") == 974)
  1133.                      {
  1134.                         set("\x01",eval("\x01") + 17);
  1135.                         ┬º┬ºpush(true);
  1136.                         continue;
  1137.                      }
  1138.                      if(eval("\x01") == 806)
  1139.                      {
  1140.                         set("\x01",eval("\x01") + 160);
  1141.                         if(┬º┬ºpop())
  1142.                         {
  1143.                            set("\x01",eval("\x01") - 202);
  1144.                         }
  1145.                         continue;
  1146.                      }
  1147.                      if(eval("\x01") == 288)
  1148.                      {
  1149.                         set("\x01",eval("\x01") - 7);
  1150.                         continue;
  1151.                      }
  1152.                      if(eval("\x01") == 153)
  1153.                      {
  1154.                         set("\x01",eval("\x01") + 590);
  1155.                         ┬º┬ºpush(true);
  1156.                         continue;
  1157.                      }
  1158.                      if(eval("\x01") == 111)
  1159.                      {
  1160.                         set("\x01",eval("\x01") + 457);
  1161.                         ┬º┬ºpush(┬º┬ºpop() == ┬º┬ºpop());
  1162.                      }
  1163.                      else
  1164.                      {
  1165.                         if(eval("\x01") == 196)
  1166.                         {
  1167.                            set("\x01",eval("\x01") + 116);
  1168.                            if(┬º┬ºpop())
  1169.                            {
  1170.                               set("\x01",eval("\x01") + 75);
  1171.                            }
  1172.                            continue;
  1173.                         }
  1174.                         if(eval("\x01") == 743)
  1175.                         {
  1176.                            set("\x01",eval("\x01") - 277);
  1177.                            if(┬º┬ºpop())
  1178.                            {
  1179.                               set("\x01",eval("\x01") - 200);
  1180.                            }
  1181.                            continue;
  1182.                         }
  1183.                         if(eval("\x01") == 633)
  1184.                         {
  1185.                            set("\x01",eval("\x01") - 480);
  1186.                            continue;
  1187.                         }
  1188.                         if(eval("\x01") == 568)
  1189.                         {
  1190.                            set("\x01",eval("\x01") + 88);
  1191.                            continue;
  1192.                         }
  1193.                         if(eval("\x01") == 266)
  1194.                         {
  1195.                            set("\x01",eval("\x01") + 708);
  1196.                            continue;
  1197.                         }
  1198.                         if(eval("\x01") == 991)
  1199.                         {
  1200.                            set("\x01",eval("\x01") + 1);
  1201.                            if(┬º┬ºpop())
  1202.                            {
  1203.                               set("\x01",eval("\x01") - 488);
  1204.                            }
  1205.                            continue;
  1206.                         }
  1207.                         if(eval("\x01") == 281)
  1208.                         {
  1209.                            set("\x01",eval("\x01") + 550);
  1210.                            stop();
  1211.                         }
  1212.                         else if(eval("\x01") == 992)
  1213.                         {
  1214.                            set("\x01",eval("\x01") - 488);
  1215.                         }
  1216.                         else
  1217.                         {
  1218.                            if(eval("\x01") == 862)
  1219.                            {
  1220.                               set("\x01",eval("\x01") - 388);
  1221.                               ┬º┬ºpush(true);
  1222.                               continue;
  1223.                            }
  1224.                            if(eval("\x01") == 504)
  1225.                            {
  1226.                               set("\x01",eval("\x01") + 456);
  1227.                               continue;
  1228.                            }
  1229.                            if(eval("\x01") == 417)
  1230.                            {
  1231.                               set("\x01",eval("\x01") + 514);
  1232.                               continue;
  1233.                            }
  1234.                            if(eval("\x01") == 960)
  1235.                            {
  1236.                               set("\x01",eval("\x01") - 764);
  1237.                               ┬º┬ºpush(true);
  1238.                               continue;
  1239.                            }
  1240.                            if(eval("\x01") == 312)
  1241.                            {
  1242.                               set("\x01",eval("\x01") + 75);
  1243.                               addr1953:
  1244.                               set("\x01",eval("\x01") + 91);
  1245.                               addr1909:
  1246.                               if(eval("\x01") == 528)
  1247.                               {
  1248.                                  set("\x01",eval("\x01") - 387);
  1249.                                  ┬º┬ºgoto(addr1909);
  1250.                                  ┬º┬ºpush(true);
  1251.                               }
  1252.                               if(eval("\x01") == 141)
  1253.                               {
  1254.                                  set("\x01",eval("\x01") + 526);
  1255.                                  if(!┬º┬ºpop())
  1256.                                  {
  1257.                                     addr1946:
  1258.                                     ┬º┬ºgoto(addr1909);
  1259.                                  }
  1260.                                  set("\x01",eval("\x01") - 314);
  1261.                                  ┬º┬ºgoto(addr1946);
  1262.                               }
  1263.                               if(eval("\x01") == 353)
  1264.                               {
  1265.                                  ┬º┬ºgoto(addr1953);
  1266.                               }
  1267.                               if(eval("\x01") == 853)
  1268.                               {
  1269.                                  set("\x01",eval("\x01") + 1);
  1270.                                  if(!┬º┬ºpop())
  1271.                                  {
  1272.                                     addr1980:
  1273.                                     ┬º┬ºgoto(addr1909);
  1274.                                  }
  1275.                                  set("\x01",eval("\x01") - 349);
  1276.                                  ┬º┬ºgoto(addr1980);
  1277.                               }
  1278.                               if(eval("\x01") != 667)
  1279.                               {
  1280.                                  if(eval("\x01") == 75)
  1281.                                  {
  1282.                                     set("\x01",eval("\x01") + 369);
  1283.                                     ┬º┬ºgoto(addr1909);
  1284.                                  }
  1285.                                  if(eval("\x01") == 598)
  1286.                                  {
  1287.                                     set("\x01",eval("\x01") - 197);
  1288.                                     ┬º┬ºgoto(addr1909);
  1289.                                  }
  1290.                                  if(eval("\x01") != 854)
  1291.                                  {
  1292.                                     if(eval("\x01") == 505)
  1293.                                     {
  1294.                                        set("\x01",eval("\x01") - 104);
  1295.                                        ┬º┬ºgoto(addr1909);
  1296.                                     }
  1297.                                     if(eval("\x01") == 444)
  1298.                                     {
  1299.                                        set("\x01",eval("\x01") + 409);
  1300.                                        ┬º┬ºgoto(addr1909);
  1301.                                        ┬º┬ºpush(true);
  1302.                                     }
  1303.                                     if(eval("\x01") == 401)
  1304.                                     {
  1305.                                        set("\x01",eval("\x01") - 256);
  1306.                                        stop();
  1307.                                     }
  1308.                                     else if(eval("\x01") == 145)
  1309.                                     {
  1310.                                        set("\x01",eval("\x01") - 145);
  1311.                                     }
  1312.                                     ┬º┬ºgoto(addr4519);
  1313.                                  }
  1314.                                  set("\x01",eval("\x01") - 349);
  1315.                                  ┬º┬ºgoto(addr4519);
  1316.                               }
  1317.                               set("\x01",eval("\x01") - 314);
  1318.                            }
  1319.                            else
  1320.                            {
  1321.                               if(eval("\x01") == 387)
  1322.                               {
  1323.                                  set("\x01",eval("\x01") + 475);
  1324.                                  continue;
  1325.                               }
  1326.                               if(eval("\x01") == 600)
  1327.                               {
  1328.                                  set("\x01",eval("\x01") + 262);
  1329.                                  continue;
  1330.                               }
  1331.                               if(eval("\x01") == 474)
  1332.                               {
  1333.                                  set("\x01",eval("\x01") + 433);
  1334.                                  if(┬º┬ºpop())
  1335.                                  {
  1336.                                     set("\x01",eval("\x01") - 490);
  1337.                                  }
  1338.                                  continue;
  1339.                               }
  1340.                               if(eval("\x01") == 831)
  1341.                               {
  1342.                                  set("\x01",eval("\x01") - 831);
  1343.                               }
  1344.                               else if(eval("\x01") == 907)
  1345.                               {
  1346.                                  set("\x01",eval("\x01") - 490);
  1347.                                  loop3:
  1348.                                  while(true)
  1349.                                  {
  1350.                                     set(┬º┬ºpop(),eval(┬º┬ºpop()) - 585);
  1351.                                     ┬º┬ºpush(true);
  1352.                                     while(eval("\x01") != 767)
  1353.                                     {
  1354.                                        if(eval("\x01") == 147)
  1355.                                        {
  1356.                                           set("\x01",eval("\x01") + 12);
  1357.                                           continue;
  1358.                                        }
  1359.                                        if(eval("\x01") == 36)
  1360.                                        {
  1361.                                           set("\x01",eval("\x01") + 510);
  1362.                                           continue;
  1363.                                        }
  1364.                                        if(eval("\x01") == 577)
  1365.                                        {
  1366.                                           set("\x01",eval("\x01") - 31);
  1367.                                           continue;
  1368.                                        }
  1369.                                        if(eval("\x01") == 182)
  1370.                                        {
  1371.                                           set("\x01",eval("\x01") + 411);
  1372.                                           if(┬º┬ºpop())
  1373.                                           {
  1374.                                              set("\x01",eval("\x01") - 303);
  1375.                                           }
  1376.                                           continue;
  1377.                                        }
  1378.                                        if(eval("\x01") == 546)
  1379.                                        {
  1380.                                           set("\x01",eval("\x01") + 262);
  1381.                                           ┬º┬ºpush(true);
  1382.                                           continue;
  1383.                                        }
  1384.                                        if(eval("\x01") == 603)
  1385.                                        {
  1386.                                           set("\x01",eval("\x01") + 32);
  1387.                                           if(┬º┬ºpop())
  1388.                                           {
  1389.                                              set("\x01",eval("\x01") - 58);
  1390.                                           }
  1391.                                           continue;
  1392.                                        }
  1393.                                        if(eval("\x01") == 37)
  1394.                                        {
  1395.                                           set("\x01",eval("\x01") + 847);
  1396.                                           play();
  1397.                                        }
  1398.                                        else if(eval("\x01") == 635)
  1399.                                        {
  1400.                                           set("\x01",eval("\x01") - 58);
  1401.                                        }
  1402.                                        else
  1403.                                        {
  1404.                                           if(eval("\x01") == 593)
  1405.                                           {
  1406.                                              break loop3;
  1407.                                           }
  1408.                                           if(eval("\x01") == 290)
  1409.                                           {
  1410.                                              set("\x01",eval("\x01") - 131);
  1411.                                              continue;
  1412.                                           }
  1413.                                           if(eval("\x01") == 159)
  1414.                                           {
  1415.                                              set("\x01",eval("\x01") + 444);
  1416.                                              ┬º┬ºpush(true);
  1417.                                              continue;
  1418.                                           }
  1419.                                           if(eval("\x01") == 884)
  1420.                                           {
  1421.                                              set("\x01",eval("\x01") - 144);
  1422.                                              continue;
  1423.                                           }
  1424.                                           if(eval("\x01") == 808)
  1425.                                           {
  1426.                                              set("\x01",eval("\x01") - 771);
  1427.                                              if(┬º┬ºpop())
  1428.                                              {
  1429.                                                 set("\x01",eval("\x01") + 847);
  1430.                                              }
  1431.                                              continue;
  1432.                                           }
  1433.                                           if(eval("\x01") == 740)
  1434.                                           {
  1435.                                              set("\x01",eval("\x01") - 4);
  1436.                                              stop();
  1437.                                           }
  1438.                                           else
  1439.                                           {
  1440.                                              if(eval("\x01") == 417)
  1441.                                              {
  1442.                                                 set("\x01",eval("\x01") + 323);
  1443.                                                 continue;
  1444.                                              }
  1445.                                              if(eval("\x01") == 736)
  1446.                                              {
  1447.                                                 set("\x01",eval("\x01") - 736);
  1448.                                              }
  1449.                                           }
  1450.                                        }
  1451.                                     }
  1452.                                  }
  1453.                                  set("\x01",eval("\x01") - 303);
  1454.                                  loop5:
  1455.                                  while(true)
  1456.                                  {
  1457.                                     set(┬º┬ºpop(),eval(┬º┬ºpop()) + 278);
  1458.                                     while(true)
  1459.                                     {
  1460.                                        if(eval("\x01") == 212)
  1461.                                        {
  1462.                                           set("\x01",eval("\x01") + 315);
  1463.                                           ┬º┬ºpush(true);
  1464.                                           continue;
  1465.                                        }
  1466.                                        if(eval("\x01") == 494)
  1467.                                        {
  1468.                                           set("\x01",eval("\x01") - 194);
  1469.                                           ┬º┬ºpush(true);
  1470.                                           continue;
  1471.                                        }
  1472.                                        if(eval("\x01") == 135)
  1473.                                        {
  1474.                                           set("\x01",eval("\x01") + 172);
  1475.                                           ┬º┬ºpush(delete ┬º┬ºpop()[(┬º┬ºpop() - 1)()]);
  1476.                                        }
  1477.                                        else
  1478.                                        {
  1479.                                           if(eval("\x01") == 957)
  1480.                                           {
  1481.                                              set("\x01",eval("\x01") - 225);
  1482.                                              if(┬º┬ºpop())
  1483.                                              {
  1484.                                                 set("\x01",eval("\x01") - 154);
  1485.                                              }
  1486.                                              continue;
  1487.                                           }
  1488.                                           if(eval("\x01") == 928)
  1489.                                           {
  1490.                                              set("\x01",eval("\x01") - 663);
  1491.                                              ┬º┬ºpush(true);
  1492.                                              continue;
  1493.                                           }
  1494.                                           if(eval("\x01") == 604)
  1495.                                           {
  1496.                                              set("\x01",eval("\x01") - 201);
  1497.                                              ┬º┬ºpush(true);
  1498.                                              continue;
  1499.                                           }
  1500.                                           if(eval("\x01") == 100)
  1501.                                           {
  1502.                                              set("\x01",eval("\x01") + 828);
  1503.                                              continue;
  1504.                                           }
  1505.                                           if(eval("\x01") == 971)
  1506.                                           {
  1507.                                              set("\x01",eval("\x01") - 836);
  1508.                                              if(┬º┬ºpop())
  1509.                                              {
  1510.                                                 set("\x01",eval("\x01") + 172);
  1511.                                              }
  1512.                                              continue;
  1513.                                           }
  1514.                                           if(eval("\x01") == 499)
  1515.                                           {
  1516.                                              set("\x01",eval("\x01") + 472);
  1517.                                              ┬º┬ºpush(true);
  1518.                                              continue;
  1519.                                           }
  1520.                                           if(eval("\x01") == 313)
  1521.                                           {
  1522.                                              set("\x01",eval("\x01") - 58);
  1523.                                              continue;
  1524.                                           }
  1525.                                           if(eval("\x01") == 736)
  1526.                                           {
  1527.                                              set("\x01",eval("\x01") - 337);
  1528.                                              ┬º┬ºpush([]);
  1529.                                           }
  1530.                                           else
  1531.                                           {
  1532.                                              if(eval("\x01") == 362)
  1533.                                              {
  1534.                                                 set("\x01",eval("\x01") + 369);
  1535.                                                 ┬º┬ºpush(true);
  1536.                                                 continue;
  1537.                                              }
  1538.                                              if(eval("\x01") == 588)
  1539.                                              {
  1540.                                                 set("\x01",eval("\x01") + 340);
  1541.                                                 continue;
  1542.                                              }
  1543.                                              if(eval("\x01") == 265)
  1544.                                              {
  1545.                                                 set("\x01",eval("\x01") + 311);
  1546.                                                 if(┬º┬ºpop())
  1547.                                                 {
  1548.                                                    set("\x01",eval("\x01") + 185);
  1549.                                                 }
  1550.                                                 continue;
  1551.                                              }
  1552.                                              if(eval("\x01") == 326)
  1553.                                              {
  1554.                                                 break;
  1555.                                              }
  1556.                                              if(eval("\x01") == 454)
  1557.                                              {
  1558.                                                 set("\x01",eval("\x01") + 434);
  1559.                                                 continue;
  1560.                                              }
  1561.                                              if(eval("\x01") == 883)
  1562.                                              {
  1563.                                                 break loop5;
  1564.                                              }
  1565.                                              if(eval("\x01") == 403)
  1566.                                              {
  1567.                                                 set("\x01",eval("\x01") + 104);
  1568.                                                 if(┬º┬ºpop())
  1569.                                                 {
  1570.                                                    set("\x01",eval("\x01") + 81);
  1571.                                                 }
  1572.                                                 continue;
  1573.                                              }
  1574.                                              if(eval("\x01") == 731)
  1575.                                              {
  1576.                                                 set("\x01",eval("\x01") + 5);
  1577.                                                 if(┬º┬ºpop())
  1578.                                                 {
  1579.                                                    set("\x01",eval("\x01") - 337);
  1580.                                                 }
  1581.                                                 continue;
  1582.                                              }
  1583.                                              if(eval("\x01") == 307)
  1584.                                              {
  1585.                                                 set("\x01",eval("\x01") + 55);
  1586.                                                 continue;
  1587.                                              }
  1588.                                              if(eval("\x01") == 527)
  1589.                                              {
  1590.                                                 set("\x01",eval("\x01") - 150);
  1591.                                                 if(┬º┬ºpop())
  1592.                                                 {
  1593.                                                    set("\x01",eval("\x01") + 491);
  1594.                                                 }
  1595.                                                 continue;
  1596.                                              }
  1597.                                              if(eval("\x01") == 202)
  1598.                                              {
  1599.                                                 set("\x01",eval("\x01") + 252);
  1600.                                                 addr4418:
  1601.                                                 set("\x01",eval("\x01") - 747);
  1602.                                                 continue loop0;
  1603.                                              }
  1604.                                              if(eval("\x01") == 990)
  1605.                                              {
  1606.                                                 set("\x01",eval("\x01") - 107);
  1607.                                                 if(┬º┬ºpop())
  1608.                                                 {
  1609.                                                    set("\x01",eval("\x01") - 557);
  1610.                                                 }
  1611.                                                 continue;
  1612.                                              }
  1613.                                              if(eval("\x01") == 578)
  1614.                                              {
  1615.                                                 set("\x01",eval("\x01") - 79);
  1616.                                                 continue;
  1617.                                              }
  1618.                                              if(eval("\x01") == 754)
  1619.                                              {
  1620.                                                 set("\x01",eval("\x01") - 392);
  1621.                                                 continue;
  1622.                                              }
  1623.                                              if(eval("\x01") == 507)
  1624.                                              {
  1625.                                                 set("\x01",eval("\x01") + 81);
  1626.                                                 ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  1627.                                              }
  1628.                                              else
  1629.                                              {
  1630.                                                 if(eval("\x01") == 479)
  1631.                                                 {
  1632.                                                    set("\x01",eval("\x01") + 15);
  1633.                                                    continue;
  1634.                                                 }
  1635.                                                 if(eval("\x01") == 300)
  1636.                                                 {
  1637.                                                    set("\x01",eval("\x01") - 98);
  1638.                                                    if(┬º┬ºpop())
  1639.                                                    {
  1640.                                                       set("\x01",eval("\x01") + 252);
  1641.                                                    }
  1642.                                                    continue;
  1643.                                                 }
  1644.                                                 if(eval("\x01") == 93)
  1645.                                                 {
  1646.                                                    set("\x01",eval("\x01") + 406);
  1647.                                                    continue;
  1648.                                                 }
  1649.                                                 if(eval("\x01") == 576)
  1650.                                                 {
  1651.                                                    set("\x01",eval("\x01") + 185);
  1652.                                                 }
  1653.                                                 else if(eval("\x01") == 377)
  1654.                                                 {
  1655.                                                    set("\x01",eval("\x01") + 491);
  1656.                                                    ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  1657.                                                 }
  1658.                                                 else
  1659.                                                 {
  1660.                                                    if(eval("\x01") == 115)
  1661.                                                    {
  1662.                                                       set("\x01",eval("\x01") + 489);
  1663.                                                       continue;
  1664.                                                    }
  1665.                                                    if(eval("\x01") == 761)
  1666.                                                    {
  1667.                                                       set("\x01",eval("\x01") - 267);
  1668.                                                       continue;
  1669.                                                    }
  1670.                                                    if(eval("\x01") == 815)
  1671.                                                    {
  1672.                                                       set("\x01",eval("\x01") + 175);
  1673.                                                       ┬º┬ºpush(true);
  1674.                                                       continue;
  1675.                                                    }
  1676.                                                    if(eval("\x01") == 399)
  1677.                                                    {
  1678.                                                       set("\x01",eval("\x01") - 144);
  1679.                                                       continue;
  1680.                                                    }
  1681.                                                    if(eval("\x01") == 8)
  1682.                                                    {
  1683.                                                       set("\x01",eval("\x01") + 807);
  1684.                                                       continue;
  1685.                                                    }
  1686.                                                    if(eval("\x01") == 868)
  1687.                                                    {
  1688.                                                       set("\x01",eval("\x01") - 53);
  1689.                                                       continue;
  1690.                                                    }
  1691.                                                    if(eval("\x01") == 255)
  1692.                                                    {
  1693.                                                       set("\x01",eval("\x01") + 580);
  1694.                                                       stop();
  1695.                                                    }
  1696.                                                    else if(eval("\x01") == 835)
  1697.                                                    {
  1698.                                                       set("\x01",eval("\x01") - 835);
  1699.                                                    }
  1700.                                                    else
  1701.                                                    {
  1702.                                                       if(eval("\x01") == 534)
  1703.                                                       {
  1704.                                                          set("\x01",eval("\x01") + 354);
  1705.                                                          continue;
  1706.                                                       }
  1707.                                                       if(eval("\x01") == 888)
  1708.                                                       {
  1709.                                                          set("\x01",eval("\x01") + 69);
  1710.                                                          ┬º┬ºpush(true);
  1711.                                                          continue;
  1712.                                                       }
  1713.                                                       if(eval("\x01") == 732)
  1714.                                                       {
  1715.                                                          set("\x01",eval("\x01") - 154);
  1716.                                                          stopDrag();
  1717.                                                          stopAllSounds();
  1718.                                                          ┬º┬ºgoto(addr3775);
  1719.                                                          ┬º┬ºpush(┬º┬ºpop() * ┬º┬ºpop());
  1720.                                                       }
  1721.                                                    }
  1722.                                                 }
  1723.                                              }
  1724.                                           }
  1725.                                        }
  1726.                                     }
  1727.                                  }
  1728.                                  set("\x01",eval("\x01") - 557);
  1729.                               }
  1730.                            }
  1731.                         }
  1732.                      }
  1733.                   }
  1734.                }
  1735.             }
  1736.          }
  1737.       }
  1738.       else
  1739.       {
  1740.          if(eval("\x01") == 462)
  1741.          {
  1742.             set("\x01",eval("\x01") - 454);
  1743.             ┬º┬ºpush(true);
  1744.             continue;
  1745.          }
  1746.          if(eval("\x01") == 548)
  1747.          {
  1748.             set("\x01",eval("\x01") + 165);
  1749.             continue;
  1750.          }
  1751.          if(eval("\x01") == 853)
  1752.          {
  1753.             set("\x01",eval("\x01") - 536);
  1754.             if(┬º┬ºpop())
  1755.             {
  1756.                set("\x01",eval("\x01") + 526);
  1757.             }
  1758.             continue;
  1759.          }
  1760.          if(eval("\x01") == 126)
  1761.          {
  1762.             set("\x01",eval("\x01") + 8);
  1763.             continue;
  1764.          }
  1765.          if(eval("\x01") == 956)
  1766.          {
  1767.             set("\x01",eval("\x01") - 494);
  1768.             continue;
  1769.          }
  1770.          if(eval("\x01") == 661)
  1771.          {
  1772.             set("\x01",eval("\x01") + 125);
  1773.             if(┬º┬ºpop())
  1774.             {
  1775.                set("\x01",eval("\x01") - 444);
  1776.             }
  1777.             continue;
  1778.          }
  1779.          if(eval("\x01") == 687)
  1780.          {
  1781.             set("\x01",eval("\x01") - 560);
  1782.             continue;
  1783.          }
  1784.          if(eval("\x01") == 811)
  1785.          {
  1786.             set("\x01",eval("\x01") - 729);
  1787.             stop();
  1788.          }
  1789.          else
  1790.          {
  1791.             if(eval("\x01") == 134)
  1792.             {
  1793.                set("\x01",eval("\x01") + 527);
  1794.                ┬º┬ºpush(true);
  1795.                continue;
  1796.             }
  1797.             if(eval("\x01") == 363)
  1798.             {
  1799.                set("\x01",eval("\x01") + 448);
  1800.                continue;
  1801.             }
  1802.             if(eval("\x01") == 361)
  1803.             {
  1804.                set("\x01",eval("\x01") + 492);
  1805.                ┬º┬ºpush(true);
  1806.                continue;
  1807.             }
  1808.             if(eval("\x01") == 713)
  1809.             {
  1810.                set("\x01",eval("\x01") - 219);
  1811.                ┬º┬ºpush(true);
  1812.                continue;
  1813.             }
  1814.             if(eval("\x01") == 494)
  1815.             {
  1816.                set("\x01",eval("\x01") + 325);
  1817.                if(!┬º┬ºpop())
  1818.                {
  1819.                }
  1820.                ┬º┬ºgoto(addr4418);
  1821.             }
  1822.             else if(eval("\x01") == 819)
  1823.             {
  1824.                set("\x01",eval("\x01") - 747);
  1825.             }
  1826.             else
  1827.             {
  1828.                if(eval("\x01") == 280)
  1829.                {
  1830.                   set("\x01",eval("\x01") + 81);
  1831.                   continue;
  1832.                }
  1833.                if(eval("\x01") == 317)
  1834.                {
  1835.                   set("\x01",eval("\x01") + 526);
  1836.                }
  1837.                else if(eval("\x01") == 59)
  1838.                {
  1839.                   set("\x01",eval("\x01") + 351);
  1840.                }
  1841.                else
  1842.                {
  1843.                   if(eval("\x01") == 127)
  1844.                   {
  1845.                      set("\x01",eval("\x01") + 251);
  1846.                      ┬º┬ºpush(true);
  1847.                      continue;
  1848.                   }
  1849.                   if(eval("\x01") == 843)
  1850.                   {
  1851.                      set("\x01",eval("\x01") - 716);
  1852.                      continue;
  1853.                   }
  1854.                   if(eval("\x01") == 82)
  1855.                   {
  1856.                      set("\x01",eval("\x01") - 82);
  1857.                   }
  1858.                }
  1859.             }
  1860.          }
  1861.       }
  1862.    }
  1863.    ┬º┬ºgoto(addr4519);
  1864. }
  1865.